#include "jeu.h"

void collisionChecker(SDL_Rect pmur[], SDL_Rect pcaisse[], SDL_Rect pmario, int nombreDeMurs, int nombreDeCaisses, int collision[])
{
    int i,j;
    //On remet collision à 0
    for(i=0;i<4;i++)
    {
        collision[i]=0;
    }
    //On teste d'abord les limites de la fenêtre
    if(pmario.y == TFENETRE - TILE_SIZE)
        collision[BAS] = 1;
    if(pmario.y == 0)
        collision[HAUT] = 1;
    if(pmario.x == TFENETRE - TILE_SIZE)
        collision[DROITE] = 1;
    if(pmario.x == 0)
        collision[GAUCHE] = 1;
    //Ensuite on teste tous les murs (trop long!) et murs + caisses
    for(i=0;i<nombreDeMurs;i++)
    {
        for(j=0;j<nombreDeCaisses;j++)
        {
            if((pcaisse[j].y == pmario.y + TILE_SIZE && pcaisse[j].y == pmur[i].y - TILE_SIZE && pcaisse[j].x == pmur[i].x && pcaisse[j].x == pmario.x) || (pcaisse[j].y == pmario.y + TILE_SIZE && pcaisse[j].x == pmario.x && pcaisse[j].y == TFENETRE-TILE_SIZE))
                collision[BAS] = 1;
            else if(pcaisse[j].y == pmario.y - TILE_SIZE && pcaisse[j].y == pmur[i].y + TILE_SIZE && pcaisse[j].x == pmur[i].x && pcaisse[j].x == pmario.x || (pcaisse[j].y == pmario.y - TILE_SIZE && pcaisse[j].x == pmario.x && pcaisse[j].y == 0))
                collision[HAUT] = 1;
            else if(pcaisse[j].x == pmario.x + TILE_SIZE && pcaisse[j].x == pmur[i].x - TILE_SIZE && pcaisse[j].y == pmur[i].y && pcaisse[j].y == pmario.y || (pcaisse[j].x == pmario.x + TILE_SIZE && pcaisse[j].y == pmario.y && pcaisse[j].x == TFENETRE-TILE_SIZE))
                collision[DROITE] = 1;
            else if(pcaisse[j].x == pmario.x - TILE_SIZE && pcaisse[j].x == pmur[i].x + TILE_SIZE && pcaisse[j].y == pmur[i].y && pcaisse[j].y == pmario.y || (pcaisse[j].x == pmario.x - TILE_SIZE && pcaisse[j].y == pmario.y && pcaisse[j].x == 0))
                collision[GAUCHE] = 1;
        }
        if(pmur[i].y == pmario.y + TILE_SIZE && pmur[i].x == pmario.x)
            collision[BAS] = 1;
        else if(pmur[i].y == pmario.y - TILE_SIZE && pmur[i].x == pmario.x)
            collision[HAUT] = 1;
        else if(pmur[i].x == pmario.x + TILE_SIZE && pmur[i].y == pmario.y)
            collision[DROITE] = 1;
        else if(pmur[i].x == pmario.x - TILE_SIZE && pmur[i].y == pmario.y)
            collision[GAUCHE] = 1;
    }
    // Enfin on teste toutes les collisions de type caisse+caisse, et caisse+bord fenêtre
    for(i=0;i<nombreDeCaisses;i++)
    {
        for(j=0;j<nombreDeCaisses;j++)
        {
            if (pcaisse[i].y == pcaisse[j].y - TILE_SIZE && pcaisse[i].y == pmario.y + TILE_SIZE && pcaisse[i].x == pmario.x && pcaisse[j].x == pmario.x)
                collision[BAS] = 1;
            else if (pcaisse[i].y == pcaisse[j].y + TILE_SIZE && pcaisse[i].y == pmario.y - TILE_SIZE && pcaisse[i].x == pmario.x && pcaisse[j].x == pmario.x)
                collision[HAUT] = 1;
            else if (pcaisse[i].x == pcaisse[j].x - TILE_SIZE && pcaisse[i].x == pmario.x + TILE_SIZE && pcaisse[i].y == pmario.y && pcaisse[j].y == pmario.y)
                collision[DROITE] = 1;
            else if (pcaisse[i].x == pcaisse[j].x + TILE_SIZE && pcaisse[i].x == pmario.x - TILE_SIZE && pcaisse[i].y == pmario.y && pcaisse[j].y == pmario.y)
                collision[GAUCHE] = 1;
        }
        if(pcaisse[i].y == TFENETRE - TILE_SIZE && pmario.y == pcaisse[i].y - TILE_SIZE && pmario.x == pcaisse[i].x)
                collision[BAS] = 1;
        if(pcaisse[i].y == 0 && pmario.y == pcaisse[i].y + TILE_SIZE && pmario.x == pcaisse[i].x)
                collision[HAUT] = 1;
        if(pcaisse[i].x == TFENETRE - TILE_SIZE && pmario.x == pcaisse[i].x - TILE_SIZE && pmario.y == pcaisse[i].y)
                collision[DROITE] = 1;
        if(pcaisse[i].x == 0 && pmario.x == pcaisse[i].x + TILE_SIZE && pmario.y == pcaisse[i].y)
                collision[GAUCHE] = 1;
    }
}

// Cette fonction permet de savoir combien de caisses sont validées et leurs coordonnées
void caisseValidee(int nObjectifs, int nombreDeCaisses, int *ptrNiv, int *ptrSuite, int *ptrsource, SDL_Rect pcaisse[], SDL_Rect pobjectif[], SDL_Surface *caisse[], SDL_Surface *ecran)
{
    int i, j, valide[100]={0}, compteur=0;

    for(i=0;i<nObjectifs;i++)
    {
        for(j=0;j<nombreDeCaisses;j++)
        {
            if((pobjectif[i].x == pcaisse[j].x && pobjectif[i].y == pcaisse[j].y) || valide[j] == 1)
            {
                SDL_BlitSurface(caisse[1],NULL,ecran,&pcaisse[j]);
                valide[j]=1;
            }
            else
            {
                SDL_BlitSurface(caisse[0],NULL,ecran,&pcaisse[j]);
                valide[j]=0;
            }
        }
    }
    for(i=0;i<nombreDeCaisses;i++)
    {
        if(valide[i] == 1)
            compteur++;
    }
    if(compteur == nObjectifs && *ptrsource == 1) // Si elles sont toutes validées et qu'on joue un niveau de niveaux.lvl
    {
            (*ptrNiv)++; // On passe au niveau suivant
            *ptrSuite=1; // On a besoin de le charger, suite=1 donc dans "jeu.c" on lance la génération du niveau suivant
    }
    else if(compteur == nObjectifs && *ptrsource == 2) // Si on est dans un niveau custom.lvl
    {
            *ptrsource=1; // On rebascule sur un niveau de niveaux.lvl mais PAS le suivant, celui sur lequel on était à la base
            *ptrSuite=1;
    }
}

void lireNiveau(int map[WTILES][HTILES], int numeroNiveau, int nNiveaux, int source) // Lit le niveau selon sa source, 1:niveaux, 2:custom
{
    int i=0,j=0,k=0;
    char *string=NULL;

    string=malloc((WTILES*HTILES*nNiveaux+1)*sizeof(char));
    FILE *niveaux=NULL;

    if(source == 1)
        niveaux = fopen("Levels/niveaux.lvl", "r");
    else if(source == 2)
        niveaux = fopen("Levels/custom.lvl", "r");

    fgets(string,WTILES*HTILES*nNiveaux+1,niveaux); // Tous les niveaux se concentrent sur une seule ligne

    for(i=0;i<HTILES;i++)
    {
        for(j=0;j<WTILES;j++)
        {
            switch (string[j+i*HTILES+(numeroNiveau-1)*WTILES*HTILES])
            {
                case '0':
                    map[j][i]=0;
                    break;
                case '1':
                    map[j][i]=1;
                    break;
                case '2':
                    map[j][i]=2;
                    break;
                case '3':
                    map[j][i]=3;
                    break;
                case '4':
                    map[j][i]=4;
                    break;
                case '5':
                    map[j][i]=5;
                    break;
            }
        }
    }
    free(string);
    fclose(niveaux);
}

// On crée le niveau en chargeant map, et en répertoriant toutes les positions des objets. On compte le nombre de caisses et d'objectifs
void genererNiveau(int map[WTILES][HTILES], int *ptrnMurs, int *ptrnCaisses, int *ptrnObj, SDL_Rect pmur[], SDL_Rect *ptrpmario, SDL_Rect pcaisse[], SDL_Rect pobjectif[])
{
    int i,k;

    *ptrnMurs=0;
    *ptrnCaisses=0;
    *ptrnObj=0;

    for(i=0;i<WTILES;i++)
    {
        for(k=0;k<HTILES;k++)
        {
            switch(map[i][k])
            {
                case 1:
                    pmur[*ptrnMurs].x=i*TILE_SIZE;
                    pmur[*ptrnMurs].y=k*TILE_SIZE;
                    (*ptrnMurs)++;
                    break;
                case 2:
                    pcaisse[*ptrnCaisses].x=i*TILE_SIZE;
                    pcaisse[*ptrnCaisses].y=k*TILE_SIZE;
                    (*ptrnCaisses)++;
                    break;
                case 3:
                    pobjectif[*ptrnObj].x=i*TILE_SIZE;
                    pobjectif[*ptrnObj].y=k*TILE_SIZE;
                    (*ptrnObj)++;
                    break;
                case 4:
                    ptrpmario->x=i*TILE_SIZE;
                    ptrpmario->y=k*TILE_SIZE;
                    break;
                case 5:
                    pobjectif[*ptrnObj].x=i*TILE_SIZE;
                    pobjectif[*ptrnObj].y=k*TILE_SIZE;
                    (*ptrnObj)++;
                    pcaisse[*ptrnCaisses].x=i*TILE_SIZE;
                    pcaisse[*ptrnCaisses].y=k*TILE_SIZE;
                    (*ptrnCaisses)++;
                    break;
            }
        }
    }
}

void nombreNiveaux(int *ptrnNiveaux) // On compte combien il y a de niveaux dans le fichier niveaux.lvl
{
    int compteur=0, curseur=0;
    FILE *niveaux=NULL;

    niveaux=fopen("Levels/niveaux.lvl","r");
    curseur=fgetc(niveaux);

    while(curseur != EOF)
    {
        curseur=fgetc(niveaux);
        compteur++;
    }
    *ptrnNiveaux=compteur/(WTILES*HTILES);
}

void sauvegarder(int niveau)
{
    FILE *fichier=NULL;

    fichier=fopen("save.sav","w+");
    fprintf(fichier, "%d", niveau);
    fclose(fichier);
}

void charger(int *niveau)
{
    FILE *fichier=NULL;
    int lire=0;

    fichier=fopen("save.sav","r+");

    if(fichier != NULL)
    {
        fscanf(fichier, "%d", &lire);
        if(lire > 0 && lire < 26)
            *niveau = lire;
        else
            remove("save.sav");
    }

    fclose(fichier);
}
